const Word = require('../models/word.model');
const AIService = require('../utils/ai.service');

class WordController {
    // 创建新的单词会话
    static async createSession(req, res) {
        try {
            const { sessionName } = req.body;
            const userId = req.user.userId;

            if (!sessionName) {
                return res.status(400).json({
                    code: 400,
                    message: '缺少会话名称'
                });
            }

            const sessionId = await Word.createSession(userId, sessionName);

            res.json({
                code: 200,
                message: '会话创建成功',
                data: {
                    sessionId,
                    sessionName
                }
            });
        } catch (error) {
            console.error('创建会话错误:', error);
            res.status(500).json({
                code: 500,
                message: '创建会话失败',
                error: error.message
            });
        }
    }

    // 在会话中生成单词
    static async generateWords(req, res) {
        try {
            const { sessionId } = req.params;
            const { level } = req.body;
            const userId = req.user.userId;

            // 验证参数
            if (!level) {
                return res.status(400).json({
                    code: 400,
                    message: '缺少必要参数：level'
                });
            }

            // 验证level是否合法
            const validLevels = ['小学英语', '初中英语', '高中英语', '大学英语四级', 
                               '大学英语六级', '专业四级', '专业八级', '雅思', '托福'];
            if (!validLevels.includes(level)) {
                return res.status(400).json({
                    code: 400,
                    message: '无效的级别'
                });
            }

            // 验证会话存在
            const session = await Word.getSessionById(sessionId, userId);
            if (!session) {
                return res.status(404).json({
                    code: 404,
                    message: '会话不存在'
                });
            }

            // 获取会话历史单词记录
            const historyWords = await Word.getSessionWords(sessionId, userId);

            // 生成单词，传入历史记录
            const wordContent = await AIService.getWordsForLevel(level, historyWords);

            // 保存单词内容
            await Word.saveWords(sessionId, userId, level, wordContent);

            res.json({
                code: 200,
                message: '单词生成成功',
                data: {
                    sessionId,
                    level,
                    content: wordContent
                }
            });
        } catch (error) {
            console.error('生成单词错误:', error);
            res.status(500).json({
                code: 500,
                message: '生成单词失败',
                error: error.message
            });
        }
    }

    // 获取所有会话
    static async getSessions(req, res) {
        try {
            const userId = req.user.userId;
            const sessions = await Word.getSessions(userId);
            
            res.json({
                code: 200,
                message: '获取会话列表成功',
                data: sessions
            });
        } catch (error) {
            console.error('获取会话列表错误:', error);
            res.status(500).json({
                code: 500,
                message: '获取会话列表失败',
                error: error.message
            });
        }
    }

    // 获取会话中的单词记录
    static async getSessionWords(req, res) {
        try {
            const { sessionId } = req.params;
            const userId = req.user.userId;

            // 验证会话存在
            const session = await Word.getSessionById(sessionId, userId);
            if (!session) {
                return res.status(404).json({
                    code: 404,
                    message: '会话不存在'
                });
            }

            const words = await Word.getSessionWords(sessionId, userId);
            
            res.json({
                code: 200,
                message: '获取单词记录成功',
                data: {
                    session,
                    words
                }
            });
        } catch (error) {
            console.error('获取单词记录错误:', error);
            res.status(500).json({
                code: 500,
                message: '获取单词记录失败',
                error: error.message
            });
        }
    }

    // 更新单词通关状态
    static async updateWordCompletion(req, res) {
        try {
            const { messageId } = req.params;
            const { isCompleted } = req.body;
            const userId = req.user.userId;

            const success = await Word.updateCompletionStatus(messageId, userId, isCompleted);

            if (success) {
                res.json({
                    code: 200,
                    message: '更新通关状态成功'
                });
            } else {
                res.status(404).json({
                    code: 404,
                    message: '记录不存在'
                });
            }
        } catch (error) {
            console.error('更新通关状态错误:', error);
            res.status(500).json({
                code: 500,
                message: '更新通关状态失败',
                error: error.message
            });
        }
    }

    // 删除会话
    static async deleteSession(req, res) {
        try {
            const { sessionId } = req.params;
            const userId = req.user.userId;

            // 验证会话存在
            const session = await Word.getSessionById(sessionId, userId);
            if (!session) {
                return res.status(404).json({
                    code: 404,
                    message: '会话不存在'
                });
            }

            // 执行删除
            const success = await Word.deleteSession(sessionId, userId);

            if (success) {
                res.json({
                    code: 200,
                    message: '删除会话成功'
                });
            } else {
                res.status(500).json({
                    code: 500,
                    message: '删除会话失败'
                });
            }
        } catch (error) {
            console.error('删除会话错误:', error);
            res.status(500).json({
                code: 500,
                message: '删除会话失败',
                error: error.message
            });
        }
    }

    // 删除单词消息
    static async deleteWordMessage(req, res) {
        try {
            const { messageId } = req.params;
            const userId = req.user.userId;

            const success = await Word.deleteWordMessage(messageId, userId);

            if (success) {
                res.json({
                    code: 200,
                    message: '删除单词消息成功'
                });
            } else {
                res.status(404).json({
                    code: 404,
                    message: '消息不存在'
                });
            }
        } catch (error) {
            console.error('删除单词消息错误:', error);
            res.status(500).json({
                code: 500,
                message: '删除单词消息失败',
                error: error.message
            });
        }
    }

    // 修改会话名称
    static async updateSessionName(req, res) {
        try {
            const { sessionId } = req.params;
            const { sessionName } = req.body;
            const userId = req.user.userId;

            if (!sessionName) {
                return res.status(400).json({
                    code: 400,
                    message: '缺少会话名称'
                });
            }

            const session = await Word.getSessionById(sessionId, userId);
            if (!session) {
                return res.status(404).json({
                    code: 404,
                    message: '会话不存在'
                });
            }

            await Word.updateSessionName(sessionId, userId, sessionName);

            res.json({
                code: 200,
                message: '会话名称更新成功'
            });
        } catch (error) {
            console.error('更新会话名称错误:', error);
            res.status(500).json({
                code: 500,
                message: '更新会话名称失败',
                error: error.message
            });
        }
    }

    // 添加收藏
    static async addFavorite(req, res) {
        try {
            const { wordContent } = req.body;
            const userId = req.user.userId;

            if (!wordContent) {
                return res.status(400).json({
                    code: 400,
                    message: '缺少单词内容'
                });
            }

            await Word.addFavorite(userId, wordContent);

            res.json({
                code: 200,
                message: '添加收藏成功'
            });
        } catch (error) {
            console.error('添加收藏错误:', error);
            // 处理唯一约束冲突的情况
            if (error.code === 'ER_DUP_ENTRY') {
                return res.status(400).json({
                    code: 400,
                    message: '该单词已收藏'
                });
            }
            res.status(500).json({
                code: 500,
                message: '添加收藏失败',
                error: error.message
            });
        }
    }

    // 取消收藏
    static async removeFavorite(req, res) {
        try {
            const { favoriteId } = req.params;
            const userId = req.user.userId;

            const success = await Word.removeFavorite(favoriteId, userId);

            if (success) {
                res.json({
                    code: 200,
                    message: '取消收藏成功'
                });
            } else {
                res.status(404).json({
                    code: 404,
                    message: '收藏记录不存在'
                });
            }
        } catch (error) {
            console.error('取消收藏错误:', error);
            res.status(500).json({
                code: 500,
                message: '取消收藏失败',
                error: error.message
            });
        }
    }

    // 获取收藏列表
    static async getFavorites(req, res) {
        try {
            const userId = req.user.userId;
            const favorites = await Word.getFavorites(userId);
            
            res.json({
                code: 200,
                message: '获取收藏列表成功',
                data: favorites
            });
        } catch (error) {
            console.error('获取收藏列表错误:', error);
            res.status(500).json({
                code: 500,
                message: '获取收藏列表失败',
                error: error.message
            });
        }
    }
}

module.exports = WordController; 